{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "88dc24ff",
   "metadata": {},
   "source": [
    "## 用卷积神经网络训练Cifar100\n",
    "For this tutorial, we will use the CIFAR100 dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2411fc",
   "metadata": {},
   "source": [
    "## 1. Load and normalize CIFAR100\n",
    "Using torchvision, it's extremely easy to load CIFAR100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f7963711",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.optim.lr_scheduler as lr_scheduler\n",
    "# import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ed493286",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using PyTorch version: 1.9.1+cu111  Device: cuda\n"
     ]
    }
   ],
   "source": [
    "# Set the device\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "    torch.cuda.set_device(0)\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "print('Using PyTorch version:', torch.__version__, ' Device:', device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12bc2962",
   "metadata": {},
   "source": [
    "The output of torchvision datasets are PILImage images of range [0, 1]. We transform them to Tensors of normalized range [-1, 1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2dcf4ab3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the batch size and number of epochs\n",
    "batch_size = 128\n",
    "num_epochs = 50\n",
    "\n",
    "# Define the transformation for data preprocessing\n",
    "transform_train = transforms.Compose([\n",
    "            transforms.RandomCrop(32, padding=4),\n",
    "            transforms.RandomHorizontalFlip(),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.4914, 0.4822, 0.4465),\n",
    "                                 (0.2023, 0.1994, 0.2010)),\n",
    "        ])\n",
    "transform_test = transforms.Compose([\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.4914, 0.4822, 0.4465),\n",
    "                                 (0.2023, 0.1994, 0.2010)),\n",
    "        ])\n",
    "\n",
    "# Load the CIFAR-100 dataset\n",
    "train_dataset = torchvision.datasets.CIFAR100(root='./data', train=True, download=False, transform=transform_train)\n",
    "test_dataset = torchvision.datasets.CIFAR100(root='./data', train=False, download=False, transform=transform_test)\n",
    "\n",
    "# Create data loaders\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f934de",
   "metadata": {},
   "source": [
    "## 2. Define SEK\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "064feb7c-5acd-4d17-9d85-41f24516f1c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from functools import partial\n",
    "\n",
    "from timm.models.layers import DropPath, to_2tuple, trunc_normal_\n",
    "from timm.models.registry import register_model\n",
    "from timm.models.vision_transformer import _cfg\n",
    "import math\n",
    "class Mlp(nn.Module):\n",
    "    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):\n",
    "        super().__init__()\n",
    "        out_features = out_features or in_features\n",
    "        hidden_features = hidden_features or in_features\n",
    "        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)\n",
    "        self.dwconv = DWConv(hidden_features)\n",
    "        self.act = act_layer()\n",
    "        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)\n",
    "        self.drop = nn.Dropout(drop)\n",
    "        self.apply(self._init_weights)\n",
    "\n",
    "    def _init_weights(self, m):\n",
    "        if isinstance(m, nn.Linear):\n",
    "            trunc_normal_(m.weight, std=.02)\n",
    "            if isinstance(m, nn.Linear) and m.bias is not None:\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "        elif isinstance(m, nn.LayerNorm):\n",
    "            nn.init.constant_(m.bias, 0)\n",
    "            nn.init.constant_(m.weight, 1.0)\n",
    "        elif isinstance(m, nn.Conv2d):\n",
    "            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "            fan_out //= m.groups\n",
    "            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n",
    "            if m.bias is not None:\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.dwconv(x)\n",
    "        x = self.act(x)\n",
    "        x = self.drop(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.drop(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class LKA(nn.Module):\n",
    "    def __init__(self, dim):\n",
    "        super().__init__()\n",
    "        self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)\n",
    "        self.conv_spatial = nn.Conv2d(dim, dim, 7, stride=1, padding=9, groups=dim, dilation=3)\n",
    "        self.conv1 = nn.Conv2d(dim, dim, 1)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        u = x.clone()        \n",
    "        attn = self.conv0(x)\n",
    "        attn = self.conv_spatial(attn)\n",
    "        attn = self.conv1(attn)\n",
    "\n",
    "        return u * attn\n",
    "\n",
    "\n",
    "class Attention(nn.Module):\n",
    "    def __init__(self, d_model):\n",
    "        super().__init__()\n",
    "\n",
    "        self.proj_1 = nn.Conv2d(d_model, d_model, 1)\n",
    "        self.activation = nn.GELU()\n",
    "        self.spatial_gating_unit = LKA(d_model)\n",
    "        self.proj_2 = nn.Conv2d(d_model, d_model, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        shorcut = x.clone()\n",
    "        x = self.proj_1(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.spatial_gating_unit(x)\n",
    "        x = self.proj_2(x)\n",
    "        x = x + shorcut\n",
    "        return x\n",
    "\n",
    "\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, dim, mlp_ratio=4., drop=0.,drop_path=0., act_layer=nn.GELU):\n",
    "        super().__init__()\n",
    "        self.norm1 = nn.BatchNorm2d(dim)\n",
    "        self.attn = Attention(dim)\n",
    "        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n",
    "\n",
    "        self.norm2 = nn.BatchNorm2d(dim)\n",
    "        mlp_hidden_dim = int(dim * mlp_ratio)\n",
    "        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n",
    "        layer_scale_init_value = 1e-2            \n",
    "        self.layer_scale_1 = nn.Parameter(\n",
    "            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n",
    "        self.layer_scale_2 = nn.Parameter(\n",
    "            layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n",
    "\n",
    "        self.apply(self._init_weights)\n",
    "\n",
    "    def _init_weights(self, m):\n",
    "        if isinstance(m, nn.Linear):\n",
    "            trunc_normal_(m.weight, std=.02)\n",
    "            if isinstance(m, nn.Linear) and m.bias is not None:\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "        elif isinstance(m, nn.LayerNorm):\n",
    "            nn.init.constant_(m.bias, 0)\n",
    "            nn.init.constant_(m.weight, 1.0)\n",
    "        elif isinstance(m, nn.Conv2d):\n",
    "            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "            fan_out //= m.groups\n",
    "            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n",
    "            if m.bias is not None:\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = x  # Save the input for residual connection\n",
    "        x = x + self.drop_path(self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) * self.attn(self.norm1(x)))\n",
    "        x = x + self.drop_path(self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) * self.mlp(self.norm2(x)))\n",
    "        x = x + residual  # Add the residual connection\n",
    "        return x\n",
    "\n",
    "\n",
    "\n",
    "class OverlapPatchEmbed(nn.Module):\n",
    "    \"\"\" Image to Patch Embedding\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, img_size=224, patch_size=7, stride=4, in_chans=3, embed_dim=768):\n",
    "        super().__init__()\n",
    "        patch_size = to_2tuple(patch_size)\n",
    "        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride,\n",
    "                              padding=(patch_size[0] // 2, patch_size[1] // 2))\n",
    "        self.norm = nn.BatchNorm2d(embed_dim)\n",
    "\n",
    "        self.apply(self._init_weights)\n",
    "\n",
    "    def _init_weights(self, m):\n",
    "        if isinstance(m, nn.Linear):\n",
    "            trunc_normal_(m.weight, std=.02)\n",
    "            if isinstance(m, nn.Linear) and m.bias is not None:\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "        elif isinstance(m, nn.LayerNorm):\n",
    "            nn.init.constant_(m.bias, 0)\n",
    "            nn.init.constant_(m.weight, 1.0)\n",
    "        elif isinstance(m, nn.Conv2d):\n",
    "            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "            fan_out //= m.groups\n",
    "            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n",
    "            if m.bias is not None:\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.proj(x)\n",
    "        _, _, H, W = x.shape\n",
    "        x = self.norm(x)        \n",
    "        return x, H, W\n",
    "\n",
    "\n",
    "class VAN(nn.Module):\n",
    "    def __init__(self, img_size=224, in_chans=3, num_classes=100, embed_dims=[64, 128, 256, 512],\n",
    "                mlp_ratios=[4, 4, 4, 4], drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,\n",
    "                 depths=[3, 4, 6, 3], num_stages=4, flag=False):\n",
    "        super().__init__()\n",
    "        if flag == False:\n",
    "            self.num_classes = num_classes\n",
    "        self.depths = depths\n",
    "        self.num_stages = num_stages\n",
    "\n",
    "        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule\n",
    "        cur = 0\n",
    "\n",
    "        for i in range(num_stages):\n",
    "            patch_embed = OverlapPatchEmbed(img_size=img_size if i == 0 else img_size // (2 ** (i + 1)),\n",
    "                                            patch_size=7 if i == 0 else 3,\n",
    "                                            stride=4 if i == 0 else 2,\n",
    "                                            in_chans=in_chans if i == 0 else embed_dims[i - 1],\n",
    "                                            embed_dim=embed_dims[i])\n",
    "\n",
    "            block = nn.ModuleList([Block(\n",
    "                dim=embed_dims[i], mlp_ratio=mlp_ratios[i], drop=drop_rate, drop_path=dpr[cur + j])\n",
    "                for j in range(depths[i])])\n",
    "            norm = norm_layer(embed_dims[i])\n",
    "            cur += depths[i]\n",
    "\n",
    "            setattr(self, f\"patch_embed{i + 1}\", patch_embed)\n",
    "            setattr(self, f\"block{i + 1}\", block)\n",
    "            setattr(self, f\"norm{i + 1}\", norm)\n",
    "\n",
    "        # classification head\n",
    "        self.head = nn.Linear(embed_dims[3], num_classes) if num_classes > 0 else nn.Identity()\n",
    "\n",
    "        self.apply(self._init_weights)\n",
    "\n",
    "    def _init_weights(self, m):\n",
    "        if isinstance(m, nn.Linear):\n",
    "            trunc_normal_(m.weight, std=.02)\n",
    "            if isinstance(m, nn.Linear) and m.bias is not None:\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "        elif isinstance(m, nn.LayerNorm):\n",
    "            nn.init.constant_(m.bias, 0)\n",
    "            nn.init.constant_(m.weight, 1.0)\n",
    "        elif isinstance(m, nn.Conv2d):\n",
    "            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "            fan_out //= m.groups\n",
    "            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n",
    "            if m.bias is not None:\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "    def freeze_patch_emb(self):\n",
    "        self.patch_embed1.requires_grad = False\n",
    "\n",
    "    @torch.jit.ignore\n",
    "    def no_weight_decay(self):\n",
    "        return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'}  # has pos_embed may be better\n",
    "\n",
    "    def get_classifier(self):\n",
    "        return self.head\n",
    "\n",
    "    def reset_classifier(self, num_classes, global_pool=''):\n",
    "        self.num_classes = num_classes\n",
    "        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()\n",
    "\n",
    "    def forward_features(self, x):\n",
    "        B = x.shape[0]\n",
    "\n",
    "        for i in range(self.num_stages):\n",
    "            patch_embed = getattr(self, f\"patch_embed{i + 1}\")\n",
    "            block = getattr(self, f\"block{i + 1}\")\n",
    "            norm = getattr(self, f\"norm{i + 1}\")\n",
    "            x, H, W = patch_embed(x)\n",
    "            for blk in block:\n",
    "                x = blk(x)\n",
    "            x = x.flatten(2).transpose(1, 2)\n",
    "            x = norm(x)\n",
    "            if i != self.num_stages - 1:\n",
    "                x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()\n",
    "\n",
    "        return x.mean(dim=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.forward_features(x)\n",
    "        x = self.head(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "class DWConv(nn.Module):\n",
    "    def __init__(self, dim=768):\n",
    "        super(DWConv, self).__init__()\n",
    "        self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.dwconv(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "def _conv_filter(state_dict, patch_size=16):\n",
    "    \"\"\" convert patch embedding weight from manual patchify + linear proj to conv\"\"\"\n",
    "    out_dict = {}\n",
    "    for k, v in state_dict.items():\n",
    "        if 'patch_embed.proj.weight' in k:\n",
    "            v = v.reshape((v.shape[0], 3, patch_size, patch_size))\n",
    "        out_dict[k] = v\n",
    "\n",
    "    return out_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c2dbf7f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the model\n",
    "model = VAN().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a34acf3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the model\n",
    "# PATH = './cifar_skn3.pth'\n",
    "# model.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12312f6f",
   "metadata": {},
   "source": [
    "## 3. Define a Loss function and optimizer\n",
    "Let’s use a Classification Cross-Entropy loss and Adam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "40fbef67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the loss function and optimizer\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=5e-4)\n",
    "\n",
    "# Define the learning rate schedule\n",
    "lr_schedule_milestones = [int(num_epochs * 0.5), int(num_epochs * 0.75)]  # 50% and 75% of total training epochs\n",
    "lr_schedule_gamma = 0.1  # Learning rate reduction factor\n",
    "\n",
    "# Define the learning rate scheduler\n",
    "scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=lr_schedule_milestones, gamma=lr_schedule_gamma)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ceb4d7b",
   "metadata": {},
   "source": [
    "## 4. Train the network\n",
    "This is when things start to get interesting. We simply have to loop over our data iterator, and feed the inputs to the network and optimize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "654c8151",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists to store training and testing losses, and accuracies\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "train_accs = []\n",
    "test_accs = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3f8b32e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/50], Step [100/391], Loss: 4.4571\n",
      "Epoch [1/50], Step [200/391], Loss: 4.3295\n",
      "Epoch [1/50], Step [300/391], Loss: 4.2291\n",
      "Epoch [1/50], Test Accuracy: 13.63%\n",
      "Epoch [2/50], Step [100/391], Loss: 3.7707\n",
      "Epoch [2/50], Step [200/391], Loss: 3.7368\n",
      "Epoch [2/50], Step [300/391], Loss: 3.6981\n",
      "Epoch [2/50], Test Accuracy: 18.47%\n",
      "Epoch [3/50], Step [100/391], Loss: 3.5327\n",
      "Epoch [3/50], Step [200/391], Loss: 3.4935\n",
      "Epoch [3/50], Step [300/391], Loss: 3.4519\n",
      "Epoch [3/50], Test Accuracy: 22.35%\n",
      "Epoch [4/50], Step [100/391], Loss: 3.3063\n",
      "Epoch [4/50], Step [200/391], Loss: 3.3029\n",
      "Epoch [4/50], Step [300/391], Loss: 3.2810\n",
      "Epoch [4/50], Test Accuracy: 23.89%\n",
      "Epoch [5/50], Step [100/391], Loss: 3.1649\n",
      "Epoch [5/50], Step [200/391], Loss: 3.1506\n",
      "Epoch [5/50], Step [300/391], Loss: 3.1353\n",
      "Epoch [5/50], Test Accuracy: 27.35%\n",
      "Epoch [6/50], Step [100/391], Loss: 2.9960\n",
      "Epoch [6/50], Step [200/391], Loss: 2.9859\n",
      "Epoch [25/50], Test Accuracy: 40.56%\n",
      "Epoch [26/50], Step [100/391], Loss: 2.2533\n",
      "Epoch [26/50], Step [200/391], Loss: 2.2260\n",
      "Epoch [26/50], Step [300/391], Loss: 2.2126\n",
      "Epoch [26/50], Test Accuracy: 45.76%\n",
      "Epoch [27/50], Step [100/391], Loss: 2.1358\n",
      "Epoch [27/50], Step [200/391], Loss: 2.1414\n",
      "Epoch [27/50], Step [300/391], Loss: 2.1365\n",
      "Epoch [27/50], Test Accuracy: 46.20%\n",
      "Epoch [28/50], Step [100/391], Loss: 2.1114\n",
      "Epoch [28/50], Step [200/391], Loss: 2.1043\n",
      "Epoch [28/50], Step [300/391], Loss: 2.1073\n",
      "Epoch [28/50], Test Accuracy: 46.53%\n",
      "Epoch [29/50], Step [100/391], Loss: 2.0728\n",
      "Epoch [29/50], Step [200/391], Loss: 2.0823\n",
      "Epoch [29/50], Step [300/391], Loss: 2.0877\n",
      "Epoch [29/50], Test Accuracy: 46.67%\n",
      "Epoch [30/50], Step [100/391], Loss: 2.0759\n",
      "Epoch [30/50], Step [200/391], Loss: 2.0694\n",
      "Epoch [30/50], Step [300/391], Loss: 2.0779\n",
      "Epoch [30/50], Test Accuracy: 47.30%\n",
      "Epoch [31/50], Step [100/391], Loss: 2.0595\n",
      "Epoch [31/50], Step [200/391], Loss: 2.0491\n",
      "Epoch [31/50], Step [300/391], Loss: 2.0572\n",
      "Epoch [31/50], Test Accuracy: 46.94%\n",
      "Epoch [32/50], Step [100/391], Loss: 2.0432\n",
      "Epoch [32/50], Step [200/391], Loss: 2.0477\n",
      "Epoch [32/50], Step [300/391], Loss: 2.0595\n",
      "Epoch [32/50], Test Accuracy: 47.40%\n",
      "Epoch [33/50], Step [100/391], Loss: 2.0249\n",
      "Epoch [33/50], Step [200/391], Loss: 2.0346\n",
      "Epoch [33/50], Step [300/391], Loss: 2.0337\n",
      "Epoch [33/50], Test Accuracy: 47.44%\n",
      "Epoch [34/50], Step [100/391], Loss: 2.0373\n",
      "Epoch [34/50], Step [200/391], Loss: 2.0495\n",
      "Epoch [34/50], Step [300/391], Loss: 2.0380\n",
      "Epoch [34/50], Test Accuracy: 47.51%\n",
      "Epoch [35/50], Step [100/391], Loss: 2.0254\n",
      "Epoch [35/50], Step [200/391], Loss: 2.0281\n",
      "Epoch [35/50], Step [300/391], Loss: 2.0370\n",
      "Epoch [35/50], Test Accuracy: 47.48%\n",
      "Epoch [36/50], Step [100/391], Loss: 2.0414\n",
      "Epoch [36/50], Step [200/391], Loss: 2.0400\n",
      "Epoch [36/50], Step [300/391], Loss: 2.0357\n",
      "Epoch [36/50], Test Accuracy: 47.21%\n",
      "Epoch [37/50], Step [100/391], Loss: 2.0182\n",
      "Epoch [37/50], Step [200/391], Loss: 2.0168\n",
      "Epoch [37/50], Step [300/391], Loss: 2.0282\n",
      "Epoch [37/50], Test Accuracy: 47.39%\n",
      "Epoch [38/50], Step [100/391], Loss: 2.0037\n",
      "Epoch [38/50], Step [200/391], Loss: 1.9992\n",
      "Epoch [38/50], Step [300/391], Loss: 1.9921\n",
      "Epoch [38/50], Test Accuracy: 47.90%\n",
      "Epoch [39/50], Step [100/391], Loss: 1.9621\n",
      "Epoch [39/50], Step [200/391], Loss: 1.9666\n",
      "Epoch [39/50], Step [300/391], Loss: 1.9752\n",
      "Epoch [39/50], Test Accuracy: 48.11%\n",
      "Epoch [40/50], Step [100/391], Loss: 1.9554\n",
      "Epoch [40/50], Step [200/391], Loss: 1.9671\n",
      "Epoch [40/50], Step [300/391], Loss: 1.9664\n",
      "Epoch [40/50], Test Accuracy: 48.20%\n",
      "Epoch [41/50], Step [100/391], Loss: 1.9669\n",
      "Epoch [41/50], Step [200/391], Loss: 1.9656\n",
      "Epoch [41/50], Step [300/391], Loss: 1.9615\n",
      "Epoch [41/50], Test Accuracy: 48.13%\n",
      "Epoch [42/50], Step [100/391], Loss: 1.9497\n",
      "Epoch [42/50], Step [200/391], Loss: 1.9677\n",
      "Epoch [42/50], Step [300/391], Loss: 1.9650\n",
      "Epoch [42/50], Test Accuracy: 48.19%\n",
      "Epoch [43/50], Step [100/391], Loss: 1.9690\n",
      "Epoch [43/50], Step [200/391], Loss: 1.9608\n",
      "Epoch [43/50], Step [300/391], Loss: 1.9656\n",
      "Epoch [43/50], Test Accuracy: 48.34%\n",
      "Epoch [44/50], Step [100/391], Loss: 1.9497\n",
      "Epoch [44/50], Step [200/391], Loss: 1.9526\n",
      "Epoch [44/50], Step [300/391], Loss: 1.9593\n",
      "Epoch [44/50], Test Accuracy: 48.42%\n",
      "Epoch [45/50], Step [100/391], Loss: 1.9882\n",
      "Epoch [45/50], Step [200/391], Loss: 1.9701\n",
      "Epoch [45/50], Step [300/391], Loss: 1.9657\n",
      "Epoch [45/50], Test Accuracy: 48.31%\n",
      "Epoch [46/50], Step [100/391], Loss: 1.9401\n",
      "Epoch [46/50], Step [200/391], Loss: 1.9603\n",
      "Epoch [46/50], Step [300/391], Loss: 1.9601\n",
      "Epoch [46/50], Test Accuracy: 48.45%\n",
      "Epoch [47/50], Step [100/391], Loss: 1.9506\n",
      "Epoch [47/50], Step [200/391], Loss: 1.9642\n",
      "Epoch [47/50], Step [300/391], Loss: 1.9643\n",
      "Epoch [47/50], Test Accuracy: 48.31%\n",
      "Epoch [48/50], Step [100/391], Loss: 1.9506\n",
      "Epoch [48/50], Step [200/391], Loss: 1.9652\n",
      "Epoch [48/50], Step [300/391], Loss: 1.9520\n",
      "Epoch [48/50], Test Accuracy: 48.47%\n",
      "Epoch [49/50], Step [100/391], Loss: 1.9729\n",
      "Epoch [49/50], Step [200/391], Loss: 1.9567\n",
      "Epoch [49/50], Step [300/391], Loss: 1.9550\n",
      "Epoch [49/50], Test Accuracy: 48.30%\n",
      "Epoch [50/50], Step [100/391], Loss: 1.9729\n",
      "Epoch [50/50], Step [200/391], Loss: 1.9563\n",
      "Epoch [50/50], Step [300/391], Loss: 1.9565\n",
      "Epoch [50/50], Test Accuracy: 48.23%\n"
     ]
    }
   ],
   "source": [
    "# Training loop\n",
    "total_steps = len(train_loader)\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss = 0.0\n",
    "    train_total = 0\n",
    "    train_correct = 0\n",
    "\n",
    "    for i, (images, labels) in enumerate(train_loader):\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # Forward pass\n",
    "        outputs = model(images)\n",
    "        loss = criterion(outputs, labels)\n",
    "\n",
    "        # Backward and optimize\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss += loss.item()\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        train_total += labels.size(0)\n",
    "        train_correct += (predicted == labels).sum().item()\n",
    "\n",
    "        # Print training progress\n",
    "        if (i + 1) % 100 == 0:\n",
    "            print(\n",
    "                f\"Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{total_steps}], Loss: {train_loss / (i + 1):.4f}\")\n",
    "\n",
    "    train_acc = 100.0 * train_correct / train_total\n",
    "    train_losses.append(train_loss / total_steps)\n",
    "    train_accs.append(train_acc)\n",
    "    \n",
    "    scheduler.step()\n",
    "    # Evaluation on the test set\n",
    "    model.eval()\n",
    "    test_loss = 0.0\n",
    "    test_total = 0\n",
    "    test_correct = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for images, labels in test_loader:\n",
    "            images = images.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            # Forward pass\n",
    "            outputs = model(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            test_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            test_total += labels.size(0)\n",
    "            test_correct += (predicted == labels).sum().item()\n",
    "\n",
    "    test_acc = 100.0 * test_correct / test_total\n",
    "    test_losses.append(test_loss / len(test_loader))\n",
    "    test_accs.append(test_acc)\n",
    "\n",
    "    # Print test accuracy for the current epoch\n",
    "    print(f\"Epoch [{epoch+1}/{num_epochs}], Test Accuracy: {test_acc:.2f}%\")\n",
    "\n",
    "    # Switch back to training mode\n",
    "    model.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da551fa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the model\n",
    "PATH = './cifar_van.pth'\n",
    "torch.save(model.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c2df4ca",
   "metadata": {},
   "source": [
    "## 5. Test the network on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41c04eae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy of the model on the 10000 test images: 48.23%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "VAN(\n",
       "  (patch_embed1): OverlapPatchEmbed(\n",
       "    (proj): Conv2d(3, 64, kernel_size=(7, 7), stride=(4, 4), padding=(3, 3))\n",
       "    (norm): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (block1): ModuleList(\n",
       "    (0): Block(\n",
       "      (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=64)\n",
       "          (conv_spatial): Conv2d(64, 64, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=64)\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (1): Block(\n",
       "      (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=64)\n",
       "          (conv_spatial): Conv2d(64, 64, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=64)\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (2): Block(\n",
       "      (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=64)\n",
       "          (conv_spatial): Conv2d(64, 64, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=64)\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       "  (patch_embed2): OverlapPatchEmbed(\n",
       "    (proj): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (norm): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (block2): ModuleList(\n",
       "    (0): Block(\n",
       "      (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(128, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=128)\n",
       "          (conv_spatial): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=128)\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (1): Block(\n",
       "      (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(128, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=128)\n",
       "          (conv_spatial): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=128)\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (2): Block(\n",
       "      (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(128, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=128)\n",
       "          (conv_spatial): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=128)\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (3): Block(\n",
       "      (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(128, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=128)\n",
       "          (conv_spatial): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=128)\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (norm2): LayerNorm((128,), eps=1e-05, elementwise_affine=True)\n",
       "  (patch_embed3): OverlapPatchEmbed(\n",
       "    (proj): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (block3): ModuleList(\n",
       "    (0): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (1): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (2): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (3): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (4): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (5): Block(\n",
       "      (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(256, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=256)\n",
       "          (conv_spatial): Conv2d(256, 256, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=256)\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (norm3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "  (patch_embed4): OverlapPatchEmbed(\n",
       "    (proj): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (block4): ModuleList(\n",
       "    (0): Block(\n",
       "      (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(512, 512, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=512)\n",
       "          (conv_spatial): Conv2d(512, 512, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=512)\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2048)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (1): Block(\n",
       "      (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(512, 512, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=512)\n",
       "          (conv_spatial): Conv2d(512, 512, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=512)\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2048)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (2): Block(\n",
       "      (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (attn): Attention(\n",
       "        (proj_1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (activation): GELU()\n",
       "        (spatial_gating_unit): LKA(\n",
       "          (conv0): Conv2d(512, 512, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=512)\n",
       "          (conv_spatial): Conv2d(512, 512, kernel_size=(7, 7), stride=(1, 1), padding=(9, 9), dilation=(3, 3), groups=512)\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (proj_2): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (drop_path): Identity()\n",
       "      (norm2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (mlp): Mlp(\n",
       "        (fc1): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (dwconv): DWConv(\n",
       "          (dwconv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2048)\n",
       "        )\n",
       "        (act): GELU()\n",
       "        (fc2): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        (drop): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (norm4): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "  (head): Linear(in_features=512, out_features=100, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluation on the test set\n",
    "model.eval()\n",
    "test_loss = 0.0\n",
    "test_total = 0\n",
    "test_correct = 0\n",
    "\n",
    "with torch.no_grad():\n",
    "    for images, labels in test_loader:\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # Forward pass\n",
    "        outputs = model(images)\n",
    "        loss = criterion(outputs, labels)\n",
    "\n",
    "        test_loss += loss.item()\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        test_total += labels.size(0)\n",
    "        test_correct += (predicted == labels).sum().item()\n",
    "\n",
    "test_acc = 100.0 * test_correct / test_total\n",
    "test_losses.append(test_loss / len(test_loader))\n",
    "test_accs.append(test_acc)\n",
    "\n",
    "# Print test accuracy for the current epoch\n",
    "print(f\"Test Accuracy of the model on the {len(test_loader.dataset)} test images: {test_acc:.2f}%\")\n",
    "\n",
    "# Switch back to training mode\n",
    "model.train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08030bd2-cdee-4757-8334-c214c8010730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple/\n",
      "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (3.7.1)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (3.0.9)\n",
      "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (5.10.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (0.11.0)\n",
      "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (1.22.3)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (1.4.4)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (1.0.7)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (4.39.4)\n",
      "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (21.3)\n",
      "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (9.1.0)\n",
      "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.8/dist-packages (from importlib-resources>=3.2.0->matplotlib) (3.10.0)\n",
      "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib) (1.14.0)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: You are using pip version 22.0.4; however, version 23.1.2 is available.\n",
      "You should consider upgrading via the '/usr/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1a062eb-8d5e-4b99-b301-8e60b12c0b5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48.23"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_losses.pop()\n",
    "test_accs.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2dadefbb-0b41-433c-b733-46989adc83dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.1993129042130484, 2.8092213914364197, 2.6447921734821946, 2.49404142778131, 2.473123713384701, 2.3850326658804204, 2.389879321750206, 2.339691048935999, 2.3041844428340092, 2.2825408283668227, 2.2825408283668227]\n"
     ]
    }
   ],
   "source": [
    "print(test_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6197b53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1100x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot the training and testing losses\n",
    "plt.figure(figsize=(11, 5))\n",
    "plt.plot(range(1, num_epochs+1 ), train_losses, label='Training Loss')\n",
    "plt.plot(range(1, num_epochs +1 ), test_losses, label='Testing Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training and Testing Loss')\n",
    "plt.legend()\n",
    "plt.savefig(\"van_figure/5_25_10epochs_losses.png\")\n",
    "plt.show()\n",
    "\n",
    "# Plot the training and testing acc\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, num_epochs + 1), train_accs, label='Training Accuracy')\n",
    "plt.plot(range(1, num_epochs + 1), test_accs, label='Testing Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training and Testing Accuracy')\n",
    "plt.legend()\n",
    "plt.savefig(\"van_figure/5_25_10epochs_accs.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a810aea9-7d2a-4916-88e4-3c98a92160aa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
